{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils import data\n",
    "import re\n",
    "import sys\n",
    "sys.path.append(\"../\")\n",
    "from mymodel import utils\n",
    "with open(\"./time_mechine.txt\",'r',encoding=\"utf-8\") as f:\n",
    "    lines = f.readlines()\n",
    "content = [re.sub(\"[^A-Za-z]+\",\" \",line).strip().lower() for line in lines] # 将不是A-Za-z中的一个或多个字符替换为空格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokens = utils.tokenize(content,\"char\") # tokens还是分行2d的\n",
    "vocab = utils.Vocab(tokens) # 词库索引转token，token转索引\n",
    "corpus = [vocab[token] for line in tokens for token in line] # 数字表示的文本"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size, num_steps = 32, 35\n",
    "device = utils.trygpu(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "独热编码  \n",
    "F.one_hot()，输入矩阵和独热编码的长度，将长度添加到最后一个维度  \n",
    "我们现在的迭代训练是(批量数据，时间步)，一般来说要先转置，(时间步，批量数据)  \n",
    "这样输出就是(时间步，批量数据，编码)，训练时对于每一个时间步的批量数据训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 获得权重\n",
    "def get_params(vocab_size, num_hiddens, device):\n",
    "    # 以onehot为输入输出所以网络的输入输出数量\n",
    "    num_input = num_output = vocab_size\n",
    "    # 初始化权重的函数，(0, 0.01)\n",
    "    def normal(shape):\n",
    "        return torch.randn(size=shape, device=device)*0.01\n",
    "    # 有这么几个权重W_xh,W_hh,W_hy,b_xh,b_hy\n",
    "    W_xh = normal((num_input,num_hiddens))\n",
    "    W_hh = normal((num_hiddens,num_hiddens))\n",
    "    W_hy = normal((num_hiddens,num_output))\n",
    "    b_xh = torch.zeros((num_hiddens), device=device)\n",
    "    b_hy = torch.zeros((num_output), device=device)\n",
    "    params = [W_xh, W_hh, W_hy, b_xh, b_hy]\n",
    "    for param in params:\n",
    "        param.requires_grad_(True)\n",
    "    return params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 初始化隐藏状态，开始的时候是没有前一个h的必须初始化，\n",
    "# 这边初始化为0\n",
    "def init_h0(batch_size, num_hiddens, device):\n",
    "    return (torch.zeros(size=(batch_size, num_hiddens), device=device),)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rnn(inputs, h, params):\n",
    "    W_xh, W_hh, W_hy, b_xh, b_hy = params\n",
    "    H, = h\n",
    "    # print(H)\n",
    "    outputs = []\n",
    "    for X in inputs: # 这里的inputs是(时间，批量，编码)遍历时间，计算输出\n",
    "        H = torch.tanh(torch.mm(X, W_xh)\n",
    "                       + torch.mm(H, W_hh)\n",
    "                       + b_xh)\n",
    "        Y = torch.mm(H, W_hy) + b_hy\n",
    "        # 需注意outputs添加的是二维矩阵，他是个三维矩阵（times，batch_size，onehot），我们输出的时候要拼起来\n",
    "        outputs.append(Y)\n",
    "    return torch.cat(outputs, dim=0), (H,)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Any\n",
    "from torch.nn import functional as F\n",
    "\n",
    "class RNNModel:\n",
    "    def __init__(self, vocab_size, num_hiddens, device, get_params, init_h0, forward_fn) -> None:\n",
    "        self.volcab_size, self.num_hiddens = vocab_size, num_hiddens\n",
    "        self.params = get_params(vocab_size, num_hiddens, device)\n",
    "        self.init_h0, self.forward_fn = init_h0, forward_fn\n",
    "\n",
    "    def __call__(self, X, h):\n",
    "        # 前向传播\n",
    "        X = F.one_hot(X.T, self.volcab_size).type(torch.float32)\n",
    "        return self.forward_fn(X, h, self.params)\n",
    "    \n",
    "    def start_h(self, batch_size, device):\n",
    "        return self.init_h0(batch_size, self.num_hiddens, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([10, 28]), 1, torch.Size([2, 512]))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 测试是否正确\n",
    "num_hiddens=512\n",
    "X = torch.arange(10).reshape(2, 5) # 2个批，每个批有5个词\n",
    "net = RNNModel(len(vocab), num_hiddens, device, get_params, init_h0, rnn)\n",
    "h0 = net.start_h(X.shape[0], device)\n",
    "Y, new_h = net(X.to(device), h0)\n",
    "Y.shape, len(new_h), new_h[0].shape\n",
    "# 输出应该是（批大小*时间步，编码）\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 预测函数\n",
    "@utils.timer\n",
    "def predictRNN(prefix, num_preds, net, vocab, device):\n",
    "    '''\n",
    "    prefix是给出的前缀，预测这后面的内容\n",
    "    预测的数量\n",
    "    训练好的网络\n",
    "    vocab用来相互转换\n",
    "    '''\n",
    "    h = net.start_h(1, device) # 因为要预测批量为1就行\n",
    "    outputs = [vocab[prefix[0]]] # outputs里面是放的最终要输出的序列的编号，先把第一个放进去，以便循环\n",
    "    get_input = lambda:torch.tensor([outputs[-1]], device=device).reshape((1,1)) # 获取输出序列的最后一个作为网络的输入\n",
    "    # 对于已经给出的序列，先在正确的基础上搞搞h\n",
    "    for y in prefix[1:]:\n",
    "        _, h = net(get_input(), h)\n",
    "        outputs.append(vocab[y])\n",
    "    # 下面是真正的预测\n",
    "    for _ in range(num_preds):\n",
    "        y, h = net(get_input(), h)\n",
    "        outputs.append(int(y.argmax(dim=1).reshape(1))) # 独热编码转化为编号\n",
    "    return \"\".join(vocab.to_tokens(outputs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[predictRNN] run time :0.007996082305908203 seconds\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'time travellerkgynczhgyn'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictRNN(\"time traveller\", 10, net, vocab, device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "梯度剪裁\n",
    "$$\\mathbf{g} \\leftarrow \\min\\left(1, \\frac{\\theta}{\\|\\mathbf{g}\\|}\\right) \\mathbf{g}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad_clipping(net, theta):\n",
    "    if isinstance(net, nn.Module):\n",
    "        params = [p for p in net.parameters() if p.requires_grad]\n",
    "    else:\n",
    "        params = net.params\n",
    "    norm = torch.sqrt(sum(torch.sum((p.grad**2)) for p in params))\n",
    "    if norm > theta:\n",
    "        for param in params:\n",
    "            param.grad[:] *= theta/norm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mymodel\n",
    "import math\n",
    "import mymodel.Show\n",
    "\n",
    "def train_epoch(net:RNNModel, train_iter, loss, optim, device, use_random_iter):\n",
    "    h = None\n",
    "    counter = 0\n",
    "    sum = 0\n",
    "    for X, Y in train_iter:\n",
    "        counter+=1\n",
    "        if h is None or use_random_iter: # 在第一次迭代或者是用随机迭代时，每次迭代都需要初始化h\n",
    "            h = net.begin_state(batch_size=X.shape[0], device=device)\n",
    "        else:# 如果是顺序迭代的话，因为批次是紧挨的，所以说上一次的h可以连续用，这里原地detach可以切断上一次迭代的梯度\n",
    "            if isinstance(net, nn.Module) and not isinstance(h, tuple):\n",
    "                h.detach_()\n",
    "            else:\n",
    "                for s in h:\n",
    "                    s.detach_()\n",
    "        y = Y.T.reshape(-1) # 我们网络的输出是先以时间循环因此是时间1的批次接时间2的批次，Y(批量数，时间步)，因此要先转置再展平\n",
    "        X, y = X.to(device), y.to(device)\n",
    "        y_hat, h = net(X, h)\n",
    "        l = loss(y_hat, y.long()).mean()\n",
    "        sum+=l\n",
    "        if isinstance(optim, torch.optim.Optimizer):\n",
    "            optim.zero_grad()\n",
    "            l.backward()\n",
    "            grad_clipping(net, 1)\n",
    "            optim.step()\n",
    "        else:\n",
    "            l.backward()\n",
    "            grad_clipping(net, 1)\n",
    "            optim(batch_size=1)\n",
    "    return math.exp(sum/counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import IPython\n",
    "import IPython.display\n",
    "@utils.timer\n",
    "def trainRNN(showfreq , net, train_iter, vocab, lr, epochs, device, use_random_iter=False):\n",
    "    print(f\"on device{device}\")\n",
    "    loss = nn.CrossEntropyLoss()\n",
    "    myshow = mymodel.Show.show([\"train\"], \"epoches\", \"perplexity\")\n",
    "    if isinstance(net, nn.Module):\n",
    "        optim = torch.optim.SGD(net.paramters(), lr)\n",
    "    else:\n",
    "        optim = lambda batch_size: utils.sgd(net.params, lr, batch_size)\n",
    "    predict = lambda prefix: predictRNN(prefix, 50, net, vocab, device)\n",
    "    for epoch in range(epochs):\n",
    "        los = train_epoch(net, train_iter, loss, optim, device, use_random_iter)\n",
    "        if((epoch)%showfreq==0):\n",
    "            IPython.display.clear_output(wait=True)\n",
    "            print(predict(\"time traveller\"))\n",
    "            myshow.add([los])\n",
    "            myshow.show_train()\n",
    "    print(f\"困惑度 {los:.1f} device:{device}\")\n",
    "    print(predict('time traveller'))\n",
    "    print(predict('traveller'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class data_iter:\n",
    "    def __init__(self, corpus, use_random_iter=False) -> None:\n",
    "        self.random = use_random_iter\n",
    "        self.corpus = corpus\n",
    "    def __iter__(self):\n",
    "        if self.random:\n",
    "            return utils.seq_data_iter_random(self.corpus, batch_size, num_steps)\n",
    "        else:\n",
    "            return utils.seq_data_iter_seq(self.corpus, batch_size, num_steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_iter = data_iter()\n",
    "# def data_iter():\n",
    "#     return utils.seq_data_iter_seq(corpus, batch_size, num_steps)\n",
    "# train_iter = data_iter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[predictRNN] run time :0.024016857147216797 seconds\n",
      "time traveller to dear the morlocks askee ala theye incleciante \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "困惑度 2.2 device:cuda:0\n",
      "[predictRNN] run time :0.018997907638549805 seconds\n",
      "time traveller thenees lokenc i was a regules mustery of the mar\n",
      "[predictRNN] run time :0.017999887466430664 seconds\n",
      "travellerd with a sleet in a noter formelthiokedth mest the\n",
      "[trainRNN] run time :1263.6951668262482 seconds\n"
     ]
    }
   ],
   "source": [
    "epochs, lr = 500, 0.07\n",
    "trainRNN(5, net, train_iter, vocab, lr, epochs, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open(\"./2.2.pkl\",\"wb\") as f:\n",
    "    pickle.dump(net,f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[predictRNN] run time :0.045502424240112305 seconds\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'the mane cumpling and the sleep came i wolloweds and the sumplivety ond shafod aly theory the tome the mors'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictRNN(\"the man\", 100, net, vocab, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[predictRNN] run time :0.018099069595336914 seconds\n",
      "time traveller put them the mather haddred houre bafted the moon\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "困惑度 2.6 device:cuda:0\n",
      "[predictRNN] run time :0.021780729293823242 seconds\n",
      "time traveller into the sensit rand the senemance of the purjur \n",
      "[predictRNN] run time :0.015287160873413086 seconds\n",
      "travellerd on the great really of inereasthis whon the moon\n",
      "[trainRNN] run time :62.28351426124573 seconds\n"
     ]
    }
   ],
   "source": [
    "trainRNN(5, net, train_iter, vocab, 0.5, 50, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[predictRNN] run time :0.022211551666259766 seconds\n",
      "time traveller was not there was a moment a fair hair i soon dis\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "困惑度 2.1 device:cuda:0\n",
      "[predictRNN] run time :0.019767284393310547 seconds\n",
      "time traveller put however subst in that permacoured to man the \n",
      "[predictRNN] run time :0.01315164566040039 seconds\n",
      "traveller on my dind it had been no soce for the country wh\n",
      "[trainRNN] run time :529.2761437892914 seconds\n"
     ]
    }
   ],
   "source": [
    "trainRNN(5, net, train_iter, vocab, 0.5, 200, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[predictRNN] run time :0.04046821594238281 seconds\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'the time stoped it farthat commort i gat to my first and i fear to you caring of green poriting asstation under the'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictRNN(\"the time stoped\",100,net,vocab,device)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
